var bcrypt = require('../dao/bcrypt')
var {apiSuccess,apiError} = require('../dao/apirequest')
var jwt = require('../dao/jwt')


var dbmodel = require('../model/dbmodel')
var User = dbmodel.model('User')
var Friend = dbmodel.model('Friend')
var Group = dbmodel.model('Group')
var Message = dbmodel.model('Message')
var GroupUser = dbmodel.model('GroupUser')
var GroupMsg = dbmodel.model('GroupMsg')


// 查找用户
exports.findUser = function(res){
    User.find(function(err,val){
        if(err){
            console.log('用户数据查找失败' + err);
        }else{
            console.log('用户数据查找成功' + val);
            res.send(val);
        }
    })
}


// 匹配用户已经存在
exports.countUserCheckItem = (data,type)=>{
    let wherestr = {}
    wherestr[type] = data;
    console.log(wherestr);

    User.countDocuments(wherestr,function(err,result){
        if(err){
            return false
        }else{
            return (result>0)
        }
    })
}

// 匹配用户名和邮箱已经存在
exports.countUserCheck = (name,email)=>{
    let wherestr = {$or:[{name:name},{email:email}]};
    // User.countDocuments(wherestr,function(err,result){
    //     if(err){
    //         return false
    //     }else{
    //         return (result>0)
    //     }
    // })
    console.log('匹配用户名和邮箱已经存在');
    User.countDocuments(wherestr)
    .then((data) => {
        console.log(data)
        console.log('查询成功1');
    })
    .catch((err) =>{
        console.log(err);
        console.log('查询失败');
    })
}



// 新建用户
exports.buldUser = (name,email,password,res)=>{

    let pwd = bcrypt.encryption(password);
    let data ={
        name,
        email,
        pwd,
        time:new Date(),
    }
    let user = new User(data);

    let wherestr = {$or:[{name:name},{email:email}]};
    User.countDocuments(wherestr)
    .then((da) => {
        console.log(da)
        console.log('查询成功1');
        if(da>0){
            res.send(apiError({},"用户名或邮箱已存在"));
        }else{
            user.save(function(err,result){
                if(err){
                    res.send(apiError(err));
                }else{
                    res.send(apiSuccess(result))
                }
            })
        }
    })
    .catch((err) =>{
        console.log('查询失败');
        res.send(apiError(err));
    })

}

// 匹配用户表元素个数
exports.countUserValue = function(data,type,res){
    let wherestr = {}
    wherestr[type] = data;
    console.log(wherestr);

    User.countDocuments(wherestr,function(err,result){
        if(err){
            res.send(apiError(err));
        }else{
            res.send(apiSuccess(result));
        }
    })
}

// 用户验证
exports.userMatch = (data,pwd,res)=>{
    if(!data || !pwd){
         res.send(apiError({},'用户名或密码不能为空'));
         return;
    }

    let wherestr = {$or:[{name:data},{email:data}]};
    let out = {name:1,imgurl:1,pwd:1}
    User.find(wherestr,out,(err,result)=>{
        if(err){
            res.send(apiError(err));
        }else{
            if(result == ''){
                res.send(apiError(result,'用户名或密码错误'));
            }
            result.map(e=>{
                const pwdMatch = bcrypt.verification(pwd,e.pwd);
            
                if(pwdMatch){
                    let token =''
                    try {
                        console.log(e._id1,e)
                        token = jwt.generateToken(e._id1)
                    } catch (error) {
                        res.send(apiError(error,'jwt错误'));
                    }
                
                    let back = {
                        token,
                        id:e._id,
                        name:e.name,
                        imgurl:e.imgurl
                    };

                    res.send(apiSuccess(back));
                }else{
                    res.send(apiError({},'密码错误'));
                }
            })
        }
    })
}


// 搜索用户
exports.searchUser = (data,res)=>{
    let wherestr = {}
    if(data == 'yike'){
        wherestr = {}
    }else{
        wherestr = {$or:[{name:{$regex:data}},{email:{$regex:data}}]}
    }
    let out = {
        name:1,email:1,imgurl:1
    }

    User.find(wherestr,out,(err,result)=>{
        if(err){
            res.send(apiError(err,'数据库查找出错'));
        }else{
            res.send(apiSuccess(result));
        }
    })
}

// 判断是否为好友
exports.isFriend = (uid,fid,res)=>{
    let wherestr = {userID:uid,friendID:fid,state:0}
    Friend.findOne(wherestr,(err,result)=>{
        if(err){
            res.send(apiError(err,'数据库查找出错'));
        }else{
            res.send(apiSuccess(result,((result)?'是好友':'不是好友')));
        }
    })
}

// 群搜索
exports.searchGroup = (data,res)=>{
    let wherestr = {}
    if(data == 'yike'){
        wherestr = {}
    }else{
        wherestr = {$or:[{name:{$regex:data}}]}
    }
    let out = {
        name:1,imgurl:1
    }

    Group.find(wherestr,out,(err,result)=>{
        if(err){
            res.send(apiError(err,'数据库查找出错'));
        }else{
            res.send(apiSuccess(result));
        }
    })
}

// 判断是否在群内
exports.isInGroup = (uid,gid,res)=>{
    this.isGroupUser(uid,gid,res);
}
exports.isGroupUser = (uid,gid,res)=>{
    let wherestr = {userID:uid,groupID:gid}
    GroupUser.findOne(wherestr,(err,result)=>{
        if(err){
            res.send(apiError(err,'数据库查找出错'));
        }else{
            res.send(apiSuccess(result,((result)?'是在群内':'不在群内')));
        }
    })
}


// 用户详情
exports.userDetail = (id,res)=>{
    let wherestr = {"_id":id};
    let out = {pwd:0};
    User.findOne(wherestr,out,(err,result)=>{
        if(err){
            res.send(apiError(err,'数据库查找出错'));
        }else{
            res.send(apiSuccess(result));
        }
    })
}

// 用户信息修改
function update(data,update,res) {

    User.findByIdAndUpdate(data.uid,update,(err,result)=>{
        if(err){
            res.send(apiError(err,'数据库查找出错'));
        }else{
            res.send(apiSuccess({result,update},"用户信息修改成功"));
        }
    })
}

exports.userUpdate = (data,res)=>{
    let updatestr = {}

    // 密码修改 通过有pwd 判断是不是修改密码 判断异常
    // ？？？
    if(typeof(data.pwd) != 'undefined'){
        console.log('修改密码路径:',data)
        User.find({'_id':data.uid},{pwd:1},(err,result)=>{
            if(err){
                res.send(apiError(err,'数据库查找出错'));
            }else{
                
                console.log('数据库查找result:',result)
                if(result == ''){
                    res.send(apiError({},'没有找到相关数据'));
                }


                result.map(e=>{
                    console.log('数据处理result e:',e)
                    const pwdMatch = bcrypt.verification(data.pwd,e.pwd)
                    console.log('密码验证pwdMatch:',pwdMatch)
                    console.log('入参数据data:',data)
                    if(pwdMatch){
                        // 验证密码成功
                        if(data.type == 'pwd'){
                            console.log('验证密码成功data:',data)
                            updatestr[data.type] = bcrypt.encryption(data.data)
                        }else{
                            console.log('data:',data)
                            console.log('e:',e)
                            // ??? 貌似不会有这个分支
                            updatestr[data.type] = data.data;
                        }

                        update(data,updatestr,res)
                        
                    }else{
                        res.send(apiError({pwdMatch,data},'密码错误'));
                    }
                })
            }
        })

    }else{
        // 用户信息修改
        updatestr[data.type] = data.data;
        update(data,updatestr,res)
    }
}


// 好友昵称获取
exports.getMarkName = (data,res)=>{
    let wherestr = {userID:data.uid,friendID:data.fid};
    let out = {markname:1}
    Friend.findOne(wherestr,out,(err,result)=>{
        if(err){
            res.send(apiError(err,'数据库查找出错'));
        }else{
            res.send(apiSuccess(result));
        }
    })
}

// 好友昵称修改
exports.friendMarkName = (data,res)=>{
    let wherestr = {userID:data.uid,friendID:data.fid};
    let updatestr = {markname:data.name}
    Friend.updateOne(wherestr,updatestr,(err,result)=>{
        if(err){
            res.send(apiError(err,'数据库查找出错'));
        }else{
            res.send(apiSuccess(result));
        }
    })
}


// 好友表操作
// 添加好友表
exports.buildFriend = (uid,fid,state,res)=>{
    
    let data ={
        userID:uid,
        friendID:fid,
        state,
        time:new Date(),
        lastTime:new Date(),
    }
    let friend = new Friend(data);

    friend.save(function(err,result){
        if(err){
            // res.send(apiError(err));
            console.log('好友申请出错:',err)
        }else{
            // res.send(apiSuccess(result))
        }
    })
       
}

// 好友最后的通讯时间
exports.upFriendLastTime = (data)=>{
    // 需要同时更新两条数据
    let wherestr = {$or:[{userID:data.uid,friendID:data.fid},{userID:data.fid,friendID:data.uid}]};
    let updatestr = {lastTime:new Date()}

    Friend.updateMany(wherestr,updatestr,(err,result)=>{
        if(err){
            console.log("更新好友最后的通讯时间:",err)
            // res.send(apiError(err));
        }else{
            // res.send(apiSuccess(result))
        }
    })
}

// 添加一对一消息
exports.insertMsg = (uid,fid,msg,type,res)=>{
    
    let data ={
        userID:uid,
        friendID:fid,
        message:msg,
        types:type,        // 0 文字 1 图片连接 2 音频连接
        time:new Date(),
        state:0,        // 0 已读 1 未读
    }

    let message = new Message(data);

    message.save(function(err,result){
        if(err){
            res.send(apiError(err));
        }else{
            res.send(apiSuccess(result))
        }
    })

}
// 好友申请 
exports.applyFriend = (data,res)=>{
    // 判断是否申请过
    let wherestr = {userID:data.uid,friendID:data.fid}
    Friend.countDocuments(wherestr,(err,result)=>{
        if(err){
            res.send(apiError(err));
        }else{
            if(result == 0){
                this.buildFriend(data.uid,data.fid,2);
                this.buildFriend(data.fid,data.uid,1);
            }else{
                // 已经申请过好友
                this.upFriendLastTime(data);
            }
            this.insertMsg(data.uid,data.fid,data.msg,0,res);
        }
    })
    
}

// 更新好友状态  同意好友
exports.updateFriendState = (data,res)=>{
    // 修改项
    let wherestr = {$or:[{userID:data.uid,friendID:data.fid},{userID:data.fid,friendID:data.uid}]};
    Friend.updateMany(wherestr,{state:0},(err,result)=>{
        if(err){
            res.send(apiError(err));
        }else{
            res.send(apiSuccess(result))
        }
    })

}

// 拒绝好友或删除好友 
exports.deleteFriendState = (data,res)=>{
    // 修改项
    let wherestr = {$or:[{userID:data.uid,friendID:data.fid},{userID:data.fid,friendID:data.uid}]};
    Friend.deleteMany(wherestr,(err,result)=>{
        if(err){
            res.send(apiError(err));
        }else{
            res.send(apiSuccess(result))
        }
    })

}

// 好友列表
exports.getUsers = (uid,state,res)=>{
    let query  = Friend.find({});
    // 查询条件
    query.where({userID:uid,state:state})
    // 查找friendID关联的user对象
    query.populate('friendID');
    // 排序方式 最后通讯时间倒序排序
    query.sort({lastTime:-1})
    // 查询结果
    query.exec().then(e=>{
        let result = e.map(ver=>{
            console.log(ver)
            return{
                id:ver.friendID._id,
                name:ver.friendID.name,
                markname:ver.markname,
                imgurl:ver.friendID.imgurl,
                lastTime:ver.lastTime
            }
        })
        res.send(apiSuccess(result))
    }).catch(err=>{
        res.send(apiError(err,'获取好友列表失败'))
    })
}


// 按要求获取一条一对一消息
exports.getOneMsg = (data,res)=>{
    let query  = Message.find({});
    // 查询条件
    query.where({$or:[{userID:data.uid,friendID:data.fid},{userID:data.fid,friendID:data.uid}]})
    // 排序方式 最后通讯时间倒序排序
    query.sort({time:-1})
    // 查询结果
    query.exec().then(e=>{
        let result = e.map(ver=>{
            console.log(ver)
            return{
                message:ver.message,
                time:ver.time,
                types:ver.types
            }
        })
        res.send(apiSuccess(result))
    }).catch(err=>{
        res.send(apiError(err,'获取消息列表失败'))
    })
}

// 汇总一对一未读消息数
exports.unreadMsg=(data,res)=>{
    let wherestr = {userID:data.uid,firendID:data.fid,state:1};
    Message.countDocuments(wherestr,(err,result)=>{
        if(err){
            res.send(apiError(err));
        }else{
            res.send(apiSuccess(result))
        }
    })
}


// 未读消息清零
exports.updateMsg = (data,res)=>{
    let wherestr = {userID:data.uid,firendID:data.fid,state:1};
    let updatestr = {state:0}
    Message.updateMany(wherestr,updatestr,(err,result)=>{
        if(err){
            res.send(apiError(err));
        }else{
            res.send(apiSuccess(result))
        }
    })
}


// 群列表
exports.getGroup = (gid,res)=>{
    let query  = GroupUser.find({});
    // 查询条件
    query.where({userID:gid})
    // 查找friendID关联的user对象
    query.populate('groupID');
    // 排序方式 最后通讯时间倒序排序
    query.sort({lastTime:-1})
    // 查询结果
    query.exec().then(e=>{
        let result = e.map(ver=>{
            console.log(ver)
            return{
                id:ver.groupID._id,
                name:ver.groupID.name,
                markname:ver.name,
                imgurl:ver.friendID.imgurl,
                lastTime:ver.lastTime,
                tip:ver.tip
            }
        })
        res.send(apiSuccess(result))
    }).catch(err=>{
        res.send(apiError(err,'获取群列表失败'))
    })
}
// 按要求获取群消息
exports.getOneGroupMsg = (gid,res)=>{
    let query  = Message.find({});
    // 查询条件
    query.where({groupID:gid})
    query.populate('userID');
    // 排序方式 最后通讯时间倒序排序
    query.sort({time:-1})
    // 查询结果
    query.exec().then(e=>{
        let result = e.map(ver=>{
            console.log(ver)
            return{
                message:ver.message,
                time:ver.time,
                types:ver.types,
                name:ver.userID.name
            }
        })
        res.send(apiSuccess(result))
    }).catch(err=>{
        res.send(apiError(err,' 按要求获取群消息失败'))
    })
}

// 群未读消息清零
exports.updateGroupMsg = (data,res)=>{
    let wherestr = {userID:data.uid,firendID:data.fid,state:1};
    let updatestr = {state:0}
    Message.updateMany(wherestr,updatestr,(err,result)=>{
        if(err){
            res.send(apiError(err));
        }else{
            res.send(apiSuccess(result))
        }
    })
}
